home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 November: Tool Chest / Dev.CD Nov 98 TC.toast / Sample Code / Snippets / QuickTime / VDTextSample / VDTextSample.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-10  |  11.8 KB  |  520 lines  |  [TEXT/MMCC]
  1. /*
  2.     File:        VDTextSample.c
  3.     
  4.     Written by:    Larry Lai, DTS
  5.  
  6.     Copyright:    © 1995 by Apple Computer, Inc., all rights reserved.
  7.  
  8.     This snippet shows you how to draw and erase text to the video
  9.     preview image without causing flickers on the screen. It only 
  10.     works with 'vdig's that support key color (Quadra 660AV, 840AV, 
  11.     630 and PowerMac 6100/7100/8100 AVs). Read "Inside Macintosh: 
  12.     QuickTime Component" Video Digitizer Component chapter for more 
  13.     information.
  14.     
  15.     Change History (most recent first):
  16.  
  17.         <1>    2/22/95 LL    create first working version.
  18.             3/10/95    LL    add about-this-app box.
  19.     To Do:     
  20.     
  21. */
  22.  
  23. /* HEADER FILES */
  24.  
  25. #include    <Types.h>
  26. #include    <Memory.h>
  27. #include    <QuickDraw.h>
  28. #include    <Palettes.h>
  29. #include    <QDOffscreen.h>
  30. #include    <Errors.h>
  31. #include    <Fonts.h>
  32. #include    <Dialogs.h>
  33. #include    <Windows.h>
  34. #include    <Menus.h>
  35. #include    <Events.h>
  36. #include    <OSUtils.h>
  37. #include    <Resources.h>
  38. #include    <ToolUtils.h>
  39. #include    <AppleEvents.h>
  40. #include    <GestaltEqu.h>
  41. #include    <Processes.h>
  42. #include    <Aliases.h>
  43. #include    <MixedMode.h>
  44. #include    <LowMem.h>
  45. #include     <Sound.h>
  46.  
  47. #include    <Movies.h>
  48. #include    <QuickTimeComponents.h>
  49. #include     <ImageCompression.h>
  50.  
  51. /* DEFINES */
  52.  
  53. #define    appleID            128            
  54. #define    appleMenu        0
  55. #define    aboutMeCommand    1
  56.  
  57. #define    fileID            129
  58. #define textCommand        1
  59. #define    quitCommand     3
  60.  
  61. #define    aboutMeDLOG        128
  62. #define    okButton        1
  63.  
  64. #define    kSoundID        128
  65. #define    kBruceIconItem    4
  66.  
  67. /* FUNCTION PROTOTYPES*/
  68.  
  69. void CheckError(OSErr error, Str255 displayString);
  70. Boolean    IsQuickTimeInstalled(void);
  71. void initialize(void);
  72. WindowPtr makeWindow(void);
  73. SeqGrabComponent makeSequenceGrabber (WindowPtr aWindow);
  74. void makeGrabChannels (    SeqGrabComponent anSG,
  75.                         SGChannel *videoChannel,
  76.                         SGChannel *soundChannel,
  77.                         const Rect *bounds, Boolean willRecord);
  78. void EraseVideo(SeqGrabComponent aSG, WindowPtr aWindow, SGChannel theChannel);
  79. void ShowAboutMeDialog(void);
  80. void DoCommand(long mResult);
  81. pascal Boolean MyFilter(DialogPtr inputDialog, EventRecord *myDialogEvent, short *theDialogItem);
  82.  
  83. /* GLOBALS */
  84.  
  85. Boolean    done = false;
  86. Boolean showString = true;
  87. Boolean    menuKey = false;
  88. MenuHandle mymenu0, mymenu1;
  89. WindowPtr    theWindow;
  90. SeqGrabComponent    theSG;
  91. SGChannel    videoChannel, soundChannel;
  92.  
  93. /* FUNCTIONS */
  94.  
  95. void CheckError(OSErr error, Str255 displayString)
  96. {
  97.     if(error == noErr) return;
  98.     if(displayString[0] > 0)
  99.         DebugStr(displayString);
  100.     ExitToShell();
  101. }
  102.  
  103. Boolean    IsQuickTimeInstalled(void)
  104. {
  105.     short     error;
  106.     long    result;
  107.     
  108.     error = Gestalt(gestaltQuickTime, &result);
  109.     return    (error == noErr);
  110. }
  111.  
  112. void ShowAboutMeDialog(void)
  113. {
  114.     GrafPtr savePort;
  115.     DialogPtr theDialog;
  116.     Handle    theSound;
  117.     short itemHit;
  118.  
  119.     GetPort(&savePort);
  120.     theDialog = GetNewDialog(aboutMeDLOG, nil, (WindowPtr) - 1);
  121.     SetPort(theDialog);
  122.  
  123.     do
  124.     {
  125.         ModalDialog((ModalFilterProcPtr) MyFilter, &itemHit);
  126.  
  127.         switch(itemHit){
  128.             case kBruceIconItem:
  129.                 /* don't mess with Bruce */
  130.                 theSound = GetResource('snd ', kSoundID);
  131.                     if (theSound != nil) {
  132.                     SndPlay(nil, (SndListHandle)theSound, false);
  133.                     ReleaseResource(theSound);
  134.                 }
  135.                   break;
  136.                 
  137.         }
  138.  
  139.     } while (itemHit != okButton);
  140.  
  141.     CloseDialog(theDialog);
  142.  
  143.     SetPort(savePort);
  144.     return;
  145. }
  146.  
  147. // True confession: this was stolen from C.K's "DialogBits.c".
  148. pascal Boolean MyFilter(DialogPtr inputDialog, EventRecord *myDialogEvent, short *theDialogItem)
  149. {
  150.     Rect tempRect;
  151.     short tempItem;
  152.     Handle tempHandle;
  153.     Point tempPoint;
  154.     Point mousePoint;
  155.     Boolean hiLit = false;
  156.     Boolean returnVal = false;
  157.  
  158.     if (myDialogEvent->what == mouseDown) {
  159.         mousePoint = (myDialogEvent->where);
  160.         GlobalToLocal(&mousePoint);
  161.         /* First see if we're in Bruce */
  162.         GetDItem(inputDialog, kBruceIconItem, &tempItem, &tempHandle, &tempRect);
  163.         if (PtInRect(mousePoint, &tempRect)) {
  164.             /* invert my icon, and track it whilst the user holds the mouse down */
  165.             InvertRect(&tempRect);
  166.             hiLit = true;
  167.             while (StillDown()) {
  168.                 GetMouse(&tempPoint);                       /* returns point in local coords */
  169.                 if (PtInRect(tempPoint, &tempRect)) {
  170.                     /* in the rect.  See if it's hilighted or not */
  171.                     if (hiLit == false) {
  172.                         hiLit = true;
  173.                         InvertRect(&tempRect);
  174.                     }
  175.                 } else {
  176.                     /* not in the rectangle.  If it's hilit, get rid of that */
  177.                     if (hiLit == true) {
  178.                         hiLit = false;
  179.                         InvertRect(&tempRect);
  180.                     }
  181.                 }
  182.             }
  183.             if (hiLit == true) {
  184.                 /* if it's still hilited when the mouse comes up, then that means the */
  185.                 /* user stayed in and wants to take this icon action */
  186.                 InvertRect(&tempRect);                      /* clear the hiliting if it's still lit */
  187.                 *theDialogItem = kBruceIconItem;
  188.                 returnVal = true;                           /* telling the Dialog Manager we handled it, pass item back */
  189.             }
  190.         } 
  191.     }
  192.     return returnVal;
  193. }
  194.  
  195.  
  196. void initialize(void)
  197. { 
  198.     OSErr    err;
  199.     short    i;
  200.     
  201.     InitGraf (&qd.thePort);
  202.     InitFonts();
  203.     InitWindows();
  204.     InitMenus();
  205.     TEInit();
  206.     InitDialogs(nil);
  207.     MaxApplZone();
  208.     
  209.     for (i = 0; i<=10; i++)
  210.         MoreMasters();
  211.     
  212.     if(!IsQuickTimeInstalled())
  213.         CheckError(-1, "\pPlease install QuickTime and try again.");
  214.         
  215.     err = EnterMovies();
  216.     CheckError(err, "\pUnable to initialize Movie Toolbox.");
  217.     
  218.         /*    Set up menus.    */
  219.     mymenu0 = GetMenu(appleID);
  220.     AddResMenu(mymenu0, 'DRVR');
  221.     InsertMenu(mymenu0, 0);
  222.     mymenu1 = GetMenu(fileID);
  223.     InsertMenu(mymenu1, 0);
  224.     DrawMenuBar();
  225. }
  226.  
  227. WindowPtr makeWindow(void)
  228. {
  229.     WindowPtr     aWindow;
  230.     Rect         windowRect = {0, 0, 240, 320};
  231.     Rect        bestRect;
  232.     
  233.     /* figure out the best monitor for the window */
  234.     GetBestDeviceRect (nil, &bestRect);
  235.     
  236.     /* put the window in the top left corner of that monitor */
  237.     OffsetRect(&windowRect, bestRect.left + 10, bestRect.top + 50);
  238.     
  239.     /* create the window */
  240.     aWindow = NewCWindow(nil, &windowRect, "\pPreviewer",
  241.                         true, noGrowDocProc, (WindowPtr)-1,
  242.                         true, 0);
  243.             
  244.     /* and set the port to the new window */
  245.     SetPort(aWindow);
  246.     
  247.     return aWindow;
  248.     
  249. }
  250.  
  251. main (void)
  252. {
  253.     OSErr        err = noErr;
  254.     char        key;
  255.  
  256.     initialize();
  257.     theWindow = makeWindow();
  258.     theSG = makeSequenceGrabber(theWindow);
  259.     if(!theSG) return;
  260.     
  261.     makeGrabChannels(theSG, &videoChannel, &soundChannel, 
  262.                     &theWindow->portRect, false);
  263.     
  264.     if((videoChannel == nil) && (soundChannel == nil))
  265.         CheckError(err, "\pCan't start preview");
  266.         
  267.     err = SGStartPreview(theSG);
  268.     CheckError(err, "\pCan't start preview");
  269.     
  270.     while(!done) {
  271.         ICMAlignmentProcRecord alignProc;
  272.         short    part;
  273.         WindowPtr    whichWindow;
  274.         EventRecord    theEvent;
  275.         
  276.         GetNextEvent(everyEvent, &theEvent);
  277.         
  278.         switch(theEvent.what) {
  279.             case nullEvent: /*give the sequence grabber time */
  280.                 err = SGIdle (theSG);
  281.                 if(err ) done = true;
  282.                 break;
  283.                 
  284.             case updateEvt: 
  285.                 if(theEvent.message == (long) theWindow) {
  286.  
  287.                         /* inform the sequesnce grabber of the update */
  288.                     SGUpdate(theSG, nil);
  289.                     EraseVideo(theSG, theWindow, videoChannel);
  290.  
  291.                     BeginUpdate(theWindow);
  292.                     EndUpdate(theWindow);
  293.                         /*and swallow the update event */
  294.                 }
  295.                 break;
  296.             
  297.             case mouseDown:
  298.                 part = FindWindow(theEvent.where,
  299.                                             &whichWindow);
  300.                 switch(part) {
  301.                     case inSysWindow:
  302.                         SystemClick(&theEvent, whichWindow);
  303.                         break;
  304.                     case inMenuBar:
  305.                         DoCommand(MenuSelect(theEvent.where));    
  306.                     case inContent:
  307.                         /* pause until mouse button is released */
  308.                         SGPause(theSG, true);
  309.                         while (StillDown())
  310.                         ;
  311.                         SGPause(theSG, false);
  312.                         EraseVideo(theSG, theWindow, videoChannel);
  313.                         break;
  314.                     case inGoAway:
  315.                         done = TrackGoAway (theWindow, theEvent.where);
  316.                         break;
  317.                     case inDrag:
  318.                         /*pause when dragging window so video doesn't draw in
  319.                             the wrong place */
  320.                         SGPause (theSG, true);
  321.                         SGGetAlignmentProc(theSG, &alignProc);
  322.                         DragAlignedWindow(theWindow,
  323.                                             theEvent.where,
  324.                                             &qd.screenBits.bounds,
  325.                                             nil, &alignProc);
  326.                         SGPause(theSG, false);
  327.                         EraseVideo(theSG, theWindow, videoChannel);
  328.                         break;
  329.                 }
  330.                 break;
  331.             
  332.             case keyDown:
  333.             case autoKey:
  334.                     key = theEvent.message & charCodeMask;
  335.                     if (theEvent.modifiers & cmdKey)
  336.                         if (theEvent.what == keyDown)
  337.                             DoCommand(MenuKey(key));
  338.                     break;
  339.     
  340.         }
  341.     }
  342.         
  343.     /*clean up*/
  344.     SGStop (theSG);
  345.     CloseComponent(theSG);
  346.     DisposeWindow (theWindow);
  347. }
  348.  
  349. void DoCommand(long mResult)
  350. {
  351.     int theMenu;
  352.     short theItem;
  353.     Str255 daName;
  354.     GrafPtr saveThePort;
  355.  
  356.     theItem = LoWord(mResult);
  357.     theMenu = HiWord(mResult);
  358.  
  359.     switch (theMenu)
  360.     {
  361.         case appleID:
  362.             if (theItem == aboutMeCommand)
  363.                 ShowAboutMeDialog();
  364.             else
  365.             {
  366.                 GetMenuItemText(mymenu0, theItem, daName);
  367.                 GetPort(&saveThePort);
  368.                 (void)OpenDeskAcc(daName);
  369.                 SetPort(saveThePort);
  370.             }
  371.             break;
  372.  
  373.         case fileID:
  374.             switch (theItem)
  375.             {
  376.                 case textCommand:
  377.                     showString = 1 - showString;
  378.                     menuKey = true;
  379.                     EraseVideo(theSG, theWindow, videoChannel);
  380.                     break;
  381.                 case quitCommand:
  382.                     done = true;
  383.                     break;
  384.                 default:
  385.                     break;
  386.             }
  387.             break;
  388.     }
  389.     HiliteMenu(0);
  390.     return;
  391. }
  392.     
  393.  
  394. SeqGrabComponent makeSequenceGrabber (WindowPtr aWindow)
  395. {
  396.     SeqGrabComponent anSG;
  397.     OSErr err = noErr;
  398.     
  399.     /* open up the default sequence grabber */
  400.     anSG = OpenDefaultComponent (SeqGrabComponentType, 0);
  401.     if (anSG) {
  402.             /* initialize the default sequence grabber component */
  403.         err = SGInitialize(anSG);
  404.         if (!err ) {
  405.             /* set the sequence grabber's graphics world to the 
  406.                 specified window */
  407.             err = SGSetGWorld (anSG, (CGrafPtr) aWindow, nil);
  408.         }
  409.     }
  410.  
  411.     if (err && anSG) {
  412.         /* clean up on failure */
  413.         CloseComponent(anSG);
  414.         anSG = nil;
  415.     }
  416.     return anSG;
  417. }
  418.  
  419. void makeGrabChannels (SeqGrabComponent anSG,
  420.                         SGChannel *videoChannel,
  421.                         SGChannel *soundChannel,
  422.                         const Rect *bounds, Boolean willRecord)
  423. {
  424.     OSErr    err;
  425.     long    usage;
  426.     /*figure out th usage */
  427.     
  428.     usage = seqGrabPreview;
  429.     if(willRecord)
  430.         usage |= seqGrabRecord;
  431.     /* create a video channel */
  432.     err = SGNewChannel (anSG, VideoMediaType, videoChannel);
  433.     if(!err) {
  434.     
  435.     /* set boundries for new video channel */
  436.         err = SGSetChannelBounds (*videoChannel, bounds);
  437.     
  438.     /*set usage for new video channel */
  439.         if(!err)
  440.             err = SGSetChannelUsage (*videoChannel,
  441.                                         usage | seqGrabPlayDuringRecord);
  442.             
  443.         if(err) {
  444.                 /* clean up on failure */
  445.                 SGDisposeChannel(anSG, *videoChannel);
  446.                 *videoChannel = nil;
  447.         }
  448.     }
  449.     
  450.     /* create a sound channel */
  451.     err = SGNewChannel (anSG, SoundMediaType, soundChannel);
  452.     if(!err){
  453.         /*set usage of new sound channel */
  454.         err = SGSetChannelUsage (*soundChannel, usage);
  455.         if(err){
  456.             /* clean up on failure */
  457.             SGDisposeChannel(anSG, *soundChannel);
  458.             *soundChannel = nil;
  459.         }
  460.     }
  461. }
  462.  
  463.  
  464. void EraseVideo(SeqGrabComponent aSG, WindowPtr aWindow, SGChannel theChannel)
  465. {
  466.     GrafPtr                        savePort;
  467.     GDHandle                    saveGD;
  468.     RGBColor                    oldColor, rgb, myRGBColor;
  469.     VideoDigitizerComponent        aVDIG;
  470.     long                        index;
  471.     OSErr                        error;
  472.  
  473.     aVDIG = SGGetVideoDigitizerComponent(theChannel);        
  474.     error = VDGetKeyColor(aVDIG, &index);
  475.     if(error == noErr){
  476.         
  477.         /* yellow is the color for the text on display */    
  478.         myRGBColor.red = 0xFC00;
  479.         myRGBColor.green = 0xF37D;
  480.         myRGBColor.blue = 0x052F;
  481.     
  482.         GetPort(&savePort);
  483.         saveGD = GetGDevice();
  484.         SetGDevice(GetMainDevice());
  485.         SetPort(aWindow);
  486.     
  487.         if(!showString && menuKey){
  488.     
  489.                 Index2Color(index, &rgb);
  490.                 GetForeColor(&oldColor);
  491.                 RGBForeColor(&rgb);
  492.                 PaintRect(&((GrafPtr) aWindow)->portRect);
  493.                 RGBForeColor(&oldColor);
  494.                 menuKey = false;
  495.  
  496.         }
  497.         
  498.         if(showString){
  499.     
  500.             MoveTo (30,30);
  501.             TextFont (applFont);
  502.             TextSize (14);
  503.             RGBForeColor(&myRGBColor);
  504.             DrawString("\pCupertino News");    
  505.         }
  506.  
  507.         SetPort(savePort);
  508.         SetGDevice(saveGD);
  509.     }
  510.     else
  511.     {
  512.             /* can not find the key color, let's us bail */
  513.             SysBeep(10);
  514.             Alert(129, nil);        
  515.             done = true;
  516.     }
  517.     
  518. }
  519.  
  520.